/**
 * 流程图工具函数
 */

/**
 * 解析节点ID字符串为数组
 * 支持逗号分隔的字符串或数组格式
 * @param {string|string[]|null|undefined} ids - 节点ID
 * @returns {string[]} - 节点ID数组
 */
export function parseNodeIds(ids) {
  if (!ids) return [];
  if (Array.isArray(ids)) return ids.filter(id => id);
  if (typeof ids === 'string') {
    return ids.split(',').map(id => id.trim()).filter(id => id);
  }
  return [];
}

/**
 * 拓扑排序计算节点层级
 * @param {Map} nodeMap - 节点映射表
 * @returns {void}
 */
export function calculateNodeLevels(nodeMap) {
  const queue = [];
  const visited = new Set();
  
  // 找到所有起始节点（入度为0）
  nodeMap.forEach((node, id) => {
    if (node.inDegree === 0) {
      node.level = 0;
      queue.push(id);
      visited.add(id);
    }
  });
  
  // BFS遍历
  while (queue.length > 0) {
    const currentId = queue.shift();
    const currentNode = nodeMap.get(currentId);
    
    // 处理所有后续节点
    currentNode.nextNodeIds.forEach(nextId => {
      const nextNode = nodeMap.get(nextId);
      if (nextNode) {
        // 节点的层级 = 所有前驱节点的最大层级 + 1
        const preMaxLevel = Math.max(
          0,
          ...nextNode.preNodeIds.map(preId => {
            const preNode = nodeMap.get(preId);
            return preNode ? preNode.level : 0;
          })
        );
        nextNode.level = Math.max(nextNode.level, preMaxLevel + 1);
        
        if (!visited.has(nextId)) {
          visited.add(nextId);
          queue.push(nextId);
        }
      }
    });
  }
  
  // 处理未访问的孤立节点
  nodeMap.forEach((node) => {
    if (node.level === -1) {
      node.level = 0;
    }
  });
}

/**
 * 按层级分组节点
 * @param {Map} nodeMap - 节点映射表
 * @returns {Map<number, string[]>} - 层级分组
 */
export function groupNodesByLevel(nodeMap) {
  const levelGroups = new Map();
  
  nodeMap.forEach((node, id) => {
    if (!levelGroups.has(node.level)) {
      levelGroups.set(node.level, []);
    }
    levelGroups.get(node.level).push(id);
  });
  
  return levelGroups;
}

/**
 * 判断连接类型
 * @param {Object} fromNode - 起始节点
 * @param {Object} toNode - 目标节点
 * @returns {string} - 连接类型
 */
export function getConnectionType(fromNode, toNode) {
  const isParallel = fromNode.nextNodeIds.length > 1;
  const isMerge = toNode.preNodeIds.length > 1;
  
  if (isParallel && isMerge) return 'parallel-merge';
  if (isParallel) return 'parallel';
  if (isMerge) return 'merge';
  return 'serial';
}

/**
 * 计算连接线样式
 * @param {number} startX - 起始X
 * @param {number} startY - 起始Y
 * @param {number} endX - 结束X
 * @param {number} endY - 结束Y
 * @returns {Object} - 样式对象
 */
export function calculateConnectionStyle(startX, startY, endX, endY) {
  const length = Math.sqrt(
    Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2)
  );
  const angle = (Math.atan2(endY - startY, endX - startX) * 180) / Math.PI;
  
  return {
    line: {
      width: `${length}px`,
      transform: `rotate(${angle}deg)`,
      transformOrigin: '0 50%',
    },
  };
}

/**
 * 深度克隆对象
 * @param {any} obj - 要克隆的对象
 * @returns {any} - 克隆后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj;
  if (obj instanceof Date) return new Date(obj.getTime());
  if (obj instanceof Array) return obj.map(item => deepClone(item));
  if (obj instanceof Object) {
    const clonedObj = {};
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key]);
      }
    }
    return clonedObj;
  }
}

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function} - 节流后的函数
 */
export function throttle(func, wait) {
  let timeout = null;
  let previous = 0;
  
  return function(...args) {
    const now = Date.now();
    const remaining = wait - (now - previous);
    
    if (remaining <= 0) {
      if (timeout) {
        clearTimeout(timeout);
        timeout = null;
      }
      previous = now;
      func.apply(this, args);
    } else if (!timeout) {
      timeout = setTimeout(() => {
        previous = Date.now();
        timeout = null;
        func.apply(this, args);
      }, remaining);
    }
  };
}

